home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / src / demos / GL / libgobj / read.c < prev    next >
C/C++ Source or Header  |  1994-08-01  |  24KB  |  1,103 lines
  1. /*
  2.  * Copyright 1989, 1990, 1991, 1992, 1993, 1994, Silicon Graphics, Inc.
  3.  * All Rights Reserved.
  4.  *
  5.  * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, Inc.;
  6.  * the contents of this file may not be disclosed to third parties, copied or
  7.  * duplicated in any form, in whole or in part, without the prior written
  8.  * permission of Silicon Graphics, Inc.
  9.  *
  10.  * RESTRICTED RIGHTS LEGEND:
  11.  * Use, duplication or disclosure by the Government is subject to restrictions
  12.  * as set forth in subdivision (c)(1)(ii) of the Rights in Technical Data
  13.  * and Computer Software clause at DFARS 252.227-7013, and/or in similar or
  14.  * successor clauses in the FAR, DOD or NASA FAR Supplement. Unpublished -
  15.  * rights reserved under the Copyright Laws of the United States.
  16.  */
  17.  
  18. #include "gobj.h"
  19.  
  20. #include <gl.h>
  21. #include <stdio.h>
  22. #include <fcntl.h>
  23.  
  24. static char ifname[80];
  25. static FILE *ifp;
  26. static int linenumber;
  27.  
  28. static char buf[240];
  29. static int numbuf[500];
  30.  
  31. int mcount = 0;
  32. mat_t *mlist = NULL;
  33.  
  34.  
  35. object_t *readobj(char *fname)
  36. {
  37.     object_t *obj;
  38.     int i;
  39.     int at = 0;
  40.  
  41.     strncpy(ifname, fname, 80);
  42.     if ((ifp = fopen(ifname, "r")) == NULL)
  43.     {
  44.     fprintf(stderr, "readobj: can't open \"%s\"\n", ifname);
  45.     return (object_t *)(-1);
  46.     }
  47.  
  48.     if (isbinary())
  49.     {
  50.     fclose(ifp);
  51.     return(breadobj(ifname));
  52.     }
  53.     linenumber = 0;
  54.  
  55.     obj = (object_t *)malloc(sizeof(object_t));
  56.     bzero(obj, sizeof(object_t));
  57.  
  58.     obj->radius = 100.0;    /* XXX */
  59.  
  60.     while (fillbuf())
  61.     {
  62.     switch (buf[0])
  63.     {
  64.         case 'B':
  65.         readnode_list(obj, atoi(&buf[1]));
  66.         break;
  67.         case 'T':
  68.         readtrans_list(obj, atoi(&buf[1]));
  69.         break;
  70.         case 'G':
  71.         readgeom_list(obj, atoi(&buf[1]));
  72.         break;
  73.         case 'M':
  74.         readmat_list(obj, atoi(&buf[1]));
  75.         break;
  76.         case 'R':
  77.         sscanf(buf, "R%f", &obj->radius);
  78.         break;
  79.         case '0':
  80.         case '1':
  81.         case '2':
  82.         case '3':
  83.         case '4':
  84.         case '5':
  85.         case '6':
  86.         case '7':
  87.         case '8':
  88.         case '9':
  89.         /*
  90.          *  old file compatibility
  91.          */
  92.         {
  93.  
  94.             switch(at++)
  95.             {
  96.             case 0:
  97.                 readnode_list(obj, atoi(buf));
  98.                 break;
  99.             case 1:
  100.                 readtrans_list(obj, atoi(buf));
  101.                 break;
  102.             case 2:
  103.                 readgeom_list(obj, atoi(buf));
  104.                 break;
  105.                 default:
  106.                 readerror("syntax error");
  107.                 break;
  108.             }
  109.         }
  110.         break;
  111.         default:
  112.         readerror("unknown group type");
  113.         break;
  114.     }
  115.     }
  116.  
  117. #if 0
  118.     fillbuf();
  119.     if (buf[0] == 'R')
  120.     {
  121.     sscanf(buf, "R%f", &obj->radius);
  122.     fillbuf();
  123.     }
  124.     else
  125.     obj->radius = 100.0;    /* XXX */
  126.  
  127.     obj->bcount = atoi(buf);
  128.     obj->blist = (node_t *)malloc(sizeof(node_t) * obj->bcount);
  129.     for (i=0; i < obj->bcount; i++)
  130.     readnode(&obj->blist[i]);
  131.  
  132.     fillbuf();
  133.     if (obj->tcount = atoi(buf))
  134.     obj->tlist = (trans_t *)malloc(sizeof(trans_t) * obj->tcount);
  135.     for (i=0; i < obj->tcount; i++)
  136.     readtrans(&obj->tlist[i]);
  137.  
  138.     fillbuf();
  139.     obj->gcount = atoi(buf);
  140.     obj->glist = (geometry_t *)malloc(sizeof(geometry_t) * obj->gcount);
  141.     bzero(obj->glist, sizeof(geometry_t) * obj->gcount);
  142.  
  143.     for (i=0; i < obj->gcount; i++)
  144.     {
  145.     fillbuf();
  146.     obj->glist[i].type = atoi(buf);
  147.     switch(obj->glist[i].type)
  148.     {
  149.         case SSECTION:
  150.         case LTV_GEOM:
  151.         readssect(&obj->glist[i]);
  152.         break;
  153.         case FSECTION:
  154.         readfsect(&obj->glist[i]);
  155.         break;
  156.         case PSECTION:
  157.         readpsect(&obj->glist[i]);
  158.         break;
  159.         case CSECTION:
  160.         case CLS_GEOM:
  161.         case CDS_GEOM:
  162.         readcsect(&obj->glist[i]);
  163.         break;
  164.         case CPV_GEOM:
  165.         case CDV_GEOM:
  166.         readcdvgeom(&obj->glist[i]);
  167.         break;
  168.         case CPU_GEOM:
  169.         case CDU_GEOM:
  170.         readcdugeom(&obj->glist[i]);
  171.         break;
  172.         case TLPU_GEOM:
  173.         read_tlpu_geom(&obj->glist[i]);
  174.         break;
  175.         case IMU_GEOM:
  176.         read_imu_geom(&obj->glist[i]);
  177.         break;
  178.         case IMV_GEOM:
  179.         read_imv_geom(&obj->glist[i]);
  180.         break;
  181.         default:
  182.         readerror("unknown section type (%d)",obj->glist[i].type);
  183.     }
  184.     }
  185. #endif
  186.  
  187.  
  188.     fclose(ifp);
  189.  
  190.     if (obj->mcount)
  191.     resolve_mat(obj);
  192.  
  193.     return obj;
  194. }
  195.  
  196.  
  197. void readnode_list(object_t *obj, int count)
  198. {
  199.     int i;
  200.  
  201.     obj->bcount = count;
  202.     obj->blist = (node_t *)malloc(sizeof(node_t) * obj->bcount);
  203.     for (i=0; i < obj->bcount; i++)
  204.     readnode(&obj->blist[i]);
  205. }
  206.  
  207.  
  208. void readtrans_list(object_t *obj, int count)
  209. {
  210.     int i;
  211.  
  212.     if (obj->tcount = count)
  213.     obj->tlist = (trans_t *)malloc(sizeof(trans_t) * obj->tcount);
  214.     for (i=0; i < obj->tcount; i++)
  215.     readtrans(&obj->tlist[i]);
  216. }
  217.  
  218.  
  219. void readgeom_list(object_t *obj, int count)
  220. {
  221.     int i;
  222.  
  223.     obj->gcount = count;
  224.     obj->glist = (geometry_t *)malloc(sizeof(geometry_t) * obj->gcount);
  225.     bzero(obj->glist, sizeof(geometry_t) * obj->gcount);
  226.  
  227.     for (i=0; i < obj->gcount; i++)
  228.     {
  229.     fillbuf();
  230.     obj->glist[i].type = atoi(buf);
  231.     switch(obj->glist[i].type)
  232.     {
  233.         case SSECTION:
  234.         case LTV_GEOM:
  235.         readssect(&obj->glist[i]);
  236.         break;
  237.         case FSECTION:
  238.         readfsect(&obj->glist[i]);
  239.         break;
  240.         case PSECTION:
  241.         readpsect(&obj->glist[i]);
  242.         break;
  243.         case CSECTION:
  244.         case CLS_GEOM:
  245.         case CDS_GEOM:
  246.         readcsect(&obj->glist[i]);
  247.         break;
  248.         case CPV_GEOM:
  249.         case CDV_GEOM:
  250.         readcdvgeom(&obj->glist[i]);
  251.         break;
  252.         case CPU_GEOM:
  253.         case CDU_GEOM:
  254.         readcdugeom(&obj->glist[i]);
  255.         break;
  256.         case TLPU_GEOM:
  257.         read_tlpu_geom(&obj->glist[i]);
  258.         break;
  259.         case IMU_GEOM:
  260.         read_imu_geom(&obj->glist[i]);
  261.         break;
  262.         case IMV_GEOM:
  263.         read_imv_geom(&obj->glist[i]);
  264.         break;
  265.         case IPU_GEOM:
  266.         read_ipu_geom(&obj->glist[i]);
  267.         break;
  268.         case IPV_GEOM:
  269.         read_ipv_geom(&obj->glist[i]);
  270.         break;
  271.         default:
  272.         readerror("unknown section type");
  273.     }
  274.     }
  275. }
  276.  
  277.  
  278. void readmat_list(object_t *obj, int count)
  279. {
  280.     int i;
  281.  
  282.     obj->mcount = count;
  283.     obj->mlist = (int *)malloc(sizeof(int) * obj->mcount);
  284.     for (i=0; i < obj->mcount; i++)
  285.     obj->mlist[i] = readmat();
  286. }
  287.  
  288.  
  289. void readnode(node_t *np)
  290. {
  291.     fillbuf();
  292.     sscanf(buf, "%i,%i", &np->statebits, &np->modebits);
  293.     np->tcount = readcnumlist(&np->tlist);
  294.     np->scount = readblist(&np->slist, &np->stlist);
  295. }
  296.  
  297.  
  298. void readssect(geometry_t *sect)
  299. {
  300.     int i, j;
  301.     char *bp;
  302.     polygon_t *p;
  303.  
  304.     fillbuf();
  305.     sscanf(buf, "%i", §->material);
  306.     fillbuf();
  307.     sect->vcount = atoi(buf);
  308.     sect->vlist = (float **)malloc(sizeof(float *) * sect->vcount);
  309.     sect->nlist = (float **)malloc(sizeof(float *) * sect->vcount);
  310.     for (i=0; i < sect->vcount; i++)
  311.     {
  312.     sect->vlist[i] = (float *)malloc(sizeof(float) * 3);
  313.     sect->nlist[i] = (float *)malloc(sizeof(float) * 3);
  314.     fillbuf();
  315.     sscanf(buf, "%f,%f,%f,%f,%f,%f",
  316.            §->vlist[i][X], §->vlist[i][Y], §->vlist[i][Z],
  317.            §->nlist[i][X], §->nlist[i][Y], §->nlist[i][Z]);
  318.     }
  319.  
  320.     fillbuf();
  321.     sect->pcount = atoi(buf);
  322.     sect->plist = (polygon_t *)malloc(sizeof(polygon_t) * sect->pcount);
  323.     for (i=0; i < sect->pcount; i++)
  324.     {
  325.     p = §->plist[i];
  326.     p->vcount = readnumlist(&p->vnlist);
  327.     p->vlist = (float **)malloc(sizeof(float *) * p->vcount);
  328.     p->nlist = (float **)malloc(sizeof(float *) * p->vcount);
  329.     for (j=0; j < p->vcount; j++)
  330.     {
  331.         p->vlist[j] = sect->vlist[p->vnlist[j]];
  332.         p->nlist[j] = sect->nlist[p->vnlist[j]];
  333.     }
  334.     }
  335. }
  336.  
  337.  
  338. void readfsect(geometry_t *sect)
  339. {
  340.     int i, j;
  341.     char *bp;
  342.     polygon_t *p;
  343.  
  344.     fillbuf();
  345.     sscanf(buf, "%i", §->material);
  346.     fillbuf();
  347.     sect->vcount = atoi(buf);
  348.     sect->vlist = (float **)malloc(sizeof(float *) * sect->vcount);
  349.     for (i=0; i < sect->vcount; i++)
  350.     {
  351.     sect->vlist[i] = (float *)malloc(sizeof(float) * 3);
  352.     fillbuf();
  353.     sscanf(buf, "%f,%f,%f",
  354.            §->vlist[i][X], §->vlist[i][Y], §->vlist[i][Z]);
  355.     }
  356.  
  357.     fillbuf();
  358.     sect->pcount = atoi(buf);
  359.     sect->plist = (polygon_t *)malloc(sizeof(polygon_t) * sect->pcount);
  360.     for (i=0; i < sect->pcount; i++)
  361.     {
  362.     p = §->plist[i];
  363.     fscanf(ifp, "%f,%f,%f,",
  364.            &p->normal[X], &p->normal[Y], &p->normal[Z]);
  365.     p->vcount = readnumlist(&p->vnlist);
  366.     p->vlist = (float **)malloc(sizeof(float *) * p->vcount);
  367.     for (j=0; j < p->vcount; j++)
  368.         p->vlist[j] = sect->vlist[p->vnlist[j]];
  369.     }
  370. }
  371.  
  372.  
  373. void read_tlpu_geom(geometry_t *sect)
  374. {
  375.     int i, j;
  376.     char *bp;
  377.     polygon_t *p;
  378.  
  379.     fillbuf();
  380.     sscanf(buf, "%i", §->material);
  381.     fillbuf();
  382.     sect->vcount = atoi(buf);
  383.     sect->vlist = (float **)malloc(sizeof(float *) * sect->vcount);
  384.     sect->xlist = (float **)malloc(sizeof(float *) * sect->vcount);
  385.     for (i=0; i < sect->vcount; i++)
  386.     {
  387.     sect->vlist[i] = (float *)malloc(sizeof(float) * 3);
  388.     sect->xlist[i] = (float *)malloc(sizeof(float) * 2);
  389.     fillbuf();
  390.     sscanf(buf, "%f,%f,%f,%f,%f",
  391.            §->vlist[i][X], §->vlist[i][Y], §->vlist[i][Z],
  392.            §->xlist[i][0], §->xlist[i][1]);
  393.     }
  394.  
  395.     fillbuf();
  396.     sect->pcount = atoi(buf);
  397.     sect->plist = (polygon_t *)malloc(sizeof(polygon_t) * sect->pcount);
  398.     for (i=0; i < sect->pcount; i++)
  399.     {
  400.     p = §->plist[i];
  401.     fscanf(ifp, "%f,%f,%f,",
  402.            &p->normal[X], &p->normal[Y], &p->normal[Z]);
  403.     p->vcount = readnumlist(&p->vnlist);
  404.     p->vlist = (float **)malloc(sizeof(float *) * p->vcount);
  405.     p->xlist = (float **)malloc(sizeof(float *) * p->vcount);
  406.     for (j=0; j < p->vcount; j++)
  407.     {
  408.         p->vlist[j] = sect->vlist[p->vnlist[j]];
  409.         p->xlist[j] = sect->xlist[p->vnlist[j]];
  410.     }
  411.     }
  412. }
  413.  
  414.  
  415. void readpsect(geometry_t *sect)
  416. {
  417.     int i, j;
  418.     char *bp;
  419.     polygon_t *p;
  420.  
  421.     fillbuf();
  422.     sscanf(buf, "%i", §->material);
  423.     fillbuf();
  424.     sscanf(buf, "%f,%f,%f",
  425.        §->normal[X], §->normal[Y], §->normal[Z]);
  426.     fillbuf();
  427.     sect->vcount = atoi(buf);
  428.     sect->vlist = (float **)malloc(sizeof(float *) * sect->vcount);
  429.     for (i=0; i < sect->vcount; i++)
  430.     {
  431.     sect->vlist[i] = (float *)malloc(sizeof(float) * 3);
  432.     fillbuf();
  433.     sscanf(buf, "%f,%f,%f",
  434.            §->vlist[i][X], §->vlist[i][Y], §->vlist[i][Z]);
  435.     }
  436.  
  437.     fillbuf();
  438.     sect->pcount = atoi(buf);
  439.     sect->plist = (polygon_t *)malloc(sizeof(polygon_t) * sect->pcount);
  440.     for (i=0; i < sect->pcount; i++)
  441.     {
  442.     p = §->plist[i];
  443.     p->vcount = readnumlist(&p->vnlist);
  444.     p->vlist = (float **)malloc(sizeof(float *) * p->vcount);
  445.     for (j=0; j < p->vcount; j++)
  446.         p->vlist[j] = sect->vlist[p->vnlist[j]];
  447.     }
  448. }
  449.  
  450.  
  451. void readcsect(geometry_t *sect)
  452. {
  453.     int i, j;
  454.     char *bp;
  455.     polygon_t *p;
  456.  
  457.     fillbuf();
  458.     sscanf(buf, "%i", §->color);
  459.     fillbuf();
  460.     sect->vcount = atoi(buf);
  461.     sect->vlist = (float **)malloc(sizeof(float *) * sect->vcount);
  462.     for (i=0; i < sect->vcount; i++)
  463.     {
  464.     sect->vlist[i] = (float *)malloc(sizeof(float) * 3);
  465.     fillbuf();
  466.     sscanf(buf, "%f,%f,%f",
  467.            §->vlist[i][X], §->vlist[i][Y], §->vlist[i][Z]);
  468.     }
  469.  
  470.     fillbuf();
  471.     sect->pcount = atoi(buf);
  472.     sect->plist = (polygon_t *)malloc(sizeof(polygon_t) * sect->pcount);
  473.     for (i=0; i < sect->pcount; i++)
  474.     {
  475.     p = §->plist[i];
  476.     p->vcount = readnumlist(&p->vnlist);
  477.     p->vlist = (float **)malloc(sizeof(float *) * p->vcount);
  478.     for (j=0; j < p->vcount; j++)
  479.         p->vlist[j] = sect->vlist[p->vnlist[j]];
  480.     }
  481. }
  482.  
  483.  
  484. void readcdvgeom(geometry_t *sect)
  485. {
  486.     int i, j;
  487.     char *bp;
  488.     polygon_t *p;
  489.  
  490.     fillbuf();
  491.     sect->vcount = atoi(buf);
  492.     sect->vlist = (float **)malloc(sizeof(float *) * sect->vcount);
  493.     sect->clist = (long *)malloc(sizeof(long) * sect->vcount);
  494.     for (i=0; i < sect->vcount; i++)
  495.     {
  496.     sect->vlist[i] = (float *)malloc(sizeof(float) * 3);
  497.     fillbuf();
  498.     sscanf(buf, "%i,%f,%f,%f", §->clist[i], 
  499.            §->vlist[i][X], §->vlist[i][Y], §->vlist[i][Z]);
  500.     }
  501.  
  502.     fillbuf();
  503.     sect->pcount = atoi(buf);
  504.     sect->plist = (polygon_t *)malloc(sizeof(polygon_t) * sect->pcount);
  505.     for (i=0; i < sect->pcount; i++)
  506.     {
  507.     p = §->plist[i];
  508.     p->vcount = readnumlist(&p->vnlist);
  509.     p->vlist = (float **)malloc(sizeof(float *) * p->vcount);
  510.     p->clist = (long *)malloc(sizeof(long) * p->vcount);
  511.     for (j=0; j < p->vcount; j++)
  512.     {
  513.         p->vlist[j] = sect->vlist[p->vnlist[j]];
  514.         p->clist[j] = sect->clist[p->vnlist[j]];
  515.     }
  516.     }
  517. }
  518.  
  519.  
  520. void readcdugeom(geometry_t *sect)
  521. {
  522.     int i, j;
  523.     char *bp;
  524.     polygon_t *p;
  525.  
  526.     fillbuf();
  527.     sect->vcount = atoi(buf);
  528.     sect->vlist = (float **)malloc(sizeof(float *) * sect->vcount);
  529.     for (i=0; i < sect->vcount; i++)
  530.     {
  531.     sect->vlist[i] = (float *)malloc(sizeof(float) * 3);
  532.     fillbuf();
  533.     sscanf(buf, "%f,%f,%f",
  534.            §->vlist[i][X], §->vlist[i][Y], §->vlist[i][Z]);
  535.     }
  536.  
  537.     fillbuf();
  538.     sect->pcount = atoi(buf);
  539.     sect->plist = (polygon_t *)malloc(sizeof(polygon_t) * sect->pcount);
  540.     for (i=0; i < sect->pcount; i++)
  541.     {
  542.     p = §->plist[i];
  543.     fscanf(ifp, "%i,", &p->color);
  544.     p->vcount = readnumlist(&p->vnlist);
  545.     p->vlist = (float **)malloc(sizeof(float *) * p->vcount);
  546.     for (j=0; j < p->vcount; j++)
  547.         p->vlist[j] = sect->vlist[p->vnlist[j]];
  548.     }
  549. }
  550.  
  551.  
  552. void read_imu_geom(geometry_t *sect)
  553. {
  554.     int i,j,k;
  555.     char *bp;
  556.     polygon_t *p;
  557.  
  558.     fillbuf();
  559.     sect->vcount = atoi(buf);
  560.     sect->vlist = (float **)malloc(sizeof(float *) * sect->vcount);
  561.     for (i=0; i < sect->vcount; i++) 
  562.     {
  563.     sect->vlist[i] = (float *)malloc(sizeof(float) * 3);
  564.     fillbuf();
  565.     sscanf(buf, "%f,%f,%f",
  566.            §->vlist[i][X], §->vlist[i][Y], §->vlist[i][Z]);
  567.     }
  568.  
  569.     fillbuf();
  570.     sect->pcount = atoi(buf);
  571.     sect->plist = (polygon_t *)malloc(sizeof(polygon_t) * sect->pcount);
  572.     for (i=0; i < sect->pcount; i++) 
  573.     {
  574.     p = §->plist[i];
  575.     fscanf(ifp, "%d,%d,", &p->type, &p->color);
  576.     p->vcount = readnumlist(&p->vnlist);
  577.     p->vlist = (float **)malloc(sizeof(float *) * p->vcount);
  578.     for (j=0; j < p->vcount; j++) {
  579.         p->vlist[j] = sect->vlist[p->vnlist[j]];
  580.     }
  581.     }
  582. }
  583.  
  584.  
  585. void read_imv_geom(geometry_t *sect)
  586. {
  587.     int i,j,k;
  588.     char *bp;
  589.     polygon_t *p;
  590.  
  591.     fillbuf();
  592.     sect->vcount = atoi(buf);
  593.     sect->vlist = (float **)malloc(sizeof(float *) * sect->vcount);
  594.     sect->clist = (long *)malloc(sizeof(long) * sect->vcount);
  595.     for (i=0; i < sect->vcount; i++)
  596.     {
  597.     sect->vlist[i] = (float *)malloc(sizeof(float) * 3);
  598.     fillbuf();
  599.     sscanf(buf, "%f,%f,%f,%ld",
  600.            §->vlist[i][X], §->vlist[i][Y], §->vlist[i][Z],
  601.            §->clist[i]);
  602.     }
  603.  
  604.     fillbuf();
  605.     sect->pcount = atoi(buf);
  606.     sect->plist = (polygon_t *)malloc(sizeof(polygon_t) * sect->pcount);
  607.     for (i=0; i < sect->pcount; i++)
  608.     {
  609.     p = §->plist[i];
  610.     fscanf(ifp, "%d,", &p->type);
  611.     p->vcount = readnumlist(&p->vnlist);
  612.     p->vlist = (float **)malloc(sizeof(float *) * p->vcount);
  613.     for (j=0; j < p->vcount; j++) {
  614.         p->vlist[j] = sect->vlist[p->vnlist[j]];
  615.     }
  616.     }
  617. }
  618.  
  619.  
  620. void read_ipu_geom(geometry_t *sect)
  621. {
  622.     int i,j,k;
  623.     char *bp;
  624.     polygon_t *p;
  625.  
  626.     fillbuf();
  627.     sect->vcount = atoi(buf);
  628.     sect->vlist = (float **)malloc(sizeof(float *) * sect->vcount);
  629.     for (i=0; i < sect->vcount; i++) 
  630.     {
  631.     sect->vlist[i] = (float *)malloc(sizeof(float) * 3);
  632.     fillbuf();
  633.     sscanf(buf, "%f,%f,%f",
  634.            §->vlist[i][X], §->vlist[i][Y], §->vlist[i][Z]);
  635.     }
  636.  
  637.     fillbuf();
  638.     sect->pcount = atoi(buf);
  639.     sect->plist = (polygon_t *)malloc(sizeof(polygon_t) * sect->pcount);
  640.     for (i=0; i < sect->pcount; i++) 
  641.     {
  642.     p = §->plist[i];
  643.     fscanf(ifp, "%d,", &p->color);
  644.     p->vcount = readnumlist(&p->vnlist);
  645.     p->vlist = (float **)malloc(sizeof(float *) * p->vcount);
  646.     for (j=0; j < p->vcount; j++) {
  647.         p->vlist[j] = sect->vlist[p->vnlist[j]];
  648.     }
  649.     }
  650. }
  651.  
  652.  
  653. void read_ipv_geom(geometry_t *sect)
  654. {
  655.     int i,j,k;
  656.     char *bp;
  657.     polygon_t *p;
  658.  
  659.     fillbuf();
  660.     sect->vcount = atoi(buf);
  661.     sect->vlist = (float **)malloc(sizeof(float *) * sect->vcount);
  662.     sect->clist = (long *)malloc(sizeof(long) * sect->vcount);
  663.     for (i=0; i < sect->vcount; i++)
  664.     {
  665.     sect->vlist[i] = (float *)malloc(sizeof(float) * 3);
  666.     fillbuf();
  667.     sscanf(buf, "%f,%f,%f,%ld",
  668.            §->vlist[i][X], §->vlist[i][Y], §->vlist[i][Z],
  669.            §->clist[i]);
  670.     }
  671.  
  672.     fillbuf();
  673.     sect->pcount = atoi(buf);
  674.     sect->plist = (polygon_t *)malloc(sizeof(polygon_t) * sect->pcount);
  675.     for (i=0; i < sect->pcount; i++)
  676.     {
  677.     p = §->plist[i];
  678.     p->vcount = readnumlist(&p->vnlist);
  679.     p->vlist = (float **)malloc(sizeof(float *) * p->vcount);
  680.     for (j=0; j < p->vcount; j++) {
  681.         p->vlist[j] = sect->vlist[p->vnlist[j]];
  682.     }
  683.     }
  684. }
  685.  
  686.  
  687. void readtrans(trans_t *t)
  688. {
  689.     fillbuf();
  690.     t->type = atoi(buf);
  691.     switch(t->type)
  692.     {
  693.     case ROTX:
  694.     case ROTY:
  695.     case ROTZ:
  696.         sscanf(buf, "%d,%d", &t->type, &t->angle);
  697.         break;
  698.     case TRANSLATE:
  699.     case SCALE:
  700.         sscanf(buf, "%d,%f,%f,%f", &t->type, &t->x, &t->y, &t->z);
  701.         break;
  702.     default:
  703.         readerror("unknown translation type");
  704.         break;
  705.     }
  706. }
  707.  
  708.  
  709. int readnumlist(int **nlist)
  710. {
  711.     char *bp;
  712.     int i = 0;
  713.  
  714.     fillbuf();
  715.     bp = buf;
  716.  
  717.     while (*bp != '\n' && *bp != '\0' && *bp != '#')
  718.     switch (*bp)
  719.     {
  720.         case '0':
  721.         case '1':
  722.         case '2':
  723.         case '3':
  724.         case '4':
  725.         case '5':
  726.         case '6':
  727.         case '7':
  728.         case '8':
  729.         case '9':
  730.         numbuf[i++] = atoi(bp);
  731.         while (*bp >= '0' && *bp <= '9')
  732.             bp++;
  733.         break;
  734.         case ',':
  735.         bp++;
  736.         break;
  737.         case ' ':
  738.         case '\t':
  739.         bp++;
  740.         break;
  741.         case '\\':
  742.         fillbuf();
  743.         bp = buf;
  744.         break;
  745.         case '\n':
  746.         case '\0':
  747.         case '#':
  748.         break;
  749.         default:
  750.         readerror("syntax error");
  751.         break;
  752.     }
  753.  
  754.     *nlist = (int *)malloc(sizeof(int) * i);
  755.     bcopy(numbuf, *nlist, i * sizeof(int));
  756.     return(i);
  757. }
  758.  
  759.  
  760. int readcnumlist(int **nlist)
  761. {
  762.     char *bp;
  763.     int i = 0;
  764.     int count;
  765.     int *list;
  766.  
  767.     fillbuf();
  768.     bp = buf;
  769.  
  770.     count = atoi(bp);
  771.     if (count == 0)
  772.     {
  773.     *nlist = NULL;
  774.     return(0);
  775.     }
  776.     while (*bp >= '0' && *bp <= '9')
  777.     bp++;
  778.     list = (int *)malloc(sizeof(int) * count);
  779.     *nlist = list;
  780.  
  781.     while (*bp != '\n' && *bp != '\0' && *bp != '#')
  782.     switch (*bp)
  783.     {
  784.         case '0':
  785.         case '1':
  786.         case '2':
  787.         case '3':
  788.         case '4':
  789.         case '5':
  790.         case '6':
  791.         case '7':
  792.         case '8':
  793.         case '9':
  794.         if (i >= count)
  795.             readerror("too many numbers found");
  796.         list[i++] = atoi(bp);
  797.         while (*bp >= '0' && *bp <= '9')
  798.             bp++;
  799.         break;
  800.         case ',':
  801.         case ' ':
  802.         case '\t':
  803.         bp++;
  804.         break;
  805.         case '\\':
  806.         fillbuf();
  807.         bp = buf;
  808.         break;
  809.         case '\n':
  810.         case '\0':
  811.         case '#':
  812.         break;
  813.         default:
  814.         readerror("syntax error");
  815.         break;
  816.     }
  817.  
  818.     if (i != count)
  819.     readerror("too few numbers found");
  820.  
  821.     return(count);
  822. }
  823.  
  824.  
  825. int readblist(int **nlist, int **tlist)
  826. {
  827.     char *bp;
  828.     int i;
  829.     int count;
  830.     int *nl;
  831.     int *tl;
  832.  
  833.     fillbuf();
  834.     bp = buf;
  835.  
  836.     count = atoi(bp);
  837.     if (count == 0)
  838.     {
  839.     *nlist = NULL;
  840.     *tlist = NULL;
  841.     return(0);
  842.     }
  843.     while (*bp >= '0' && *bp <= '9')
  844.     bp++;
  845.  
  846.     nl = (int *)malloc(sizeof(int) * count);
  847.     *nlist = nl;
  848.  
  849.     tl = (int *)malloc(sizeof(int) * count);
  850.     *tlist = tl;
  851.     for (i=0; i<count; i++)
  852.     tl[i] = BRANCH;
  853.  
  854.     i = 0;
  855.  
  856.     while (*bp != '\n' && *bp != '\0' && *bp != '#')
  857.     switch (*bp)
  858.     {
  859.         case '0':
  860.         case '1':
  861.         case '2':
  862.         case '3':
  863.         case '4':
  864.         case '5':
  865.         case '6':
  866.         case '7':
  867.         case '8':
  868.         case '9':
  869.         if (i >= count)
  870.             readerror("too many numbers found");
  871.         nl[i++] = atoi(bp);
  872.         while (*bp >= '0' && *bp <= '9')
  873.             bp++;
  874.         break;
  875.         case 'B':
  876.         tl[i] = BRANCH;
  877.         bp++;
  878.         break;
  879.         case 'G':
  880.         tl[i] = GEOMETRY;
  881.         bp++;
  882.         break;
  883.         case ',':
  884.         case ' ':
  885.         case '\t':
  886.         bp++;
  887.         break;
  888.         case '\\':
  889.         fillbuf();
  890.         bp = buf;
  891.         break;
  892.         case '\n':
  893.         case '\0':
  894.         case '#':
  895.         break;
  896.         default:
  897.         readerror("syntax error");
  898.         break;
  899.     }
  900.  
  901.     if (i != count)
  902.     readerror("too few numbers found");
  903.  
  904.     return(count);
  905. }
  906.  
  907.  
  908. int readmat()
  909. {
  910.     float tmp[21];
  911.     int i;
  912.  
  913.     fillbuf();
  914.     tmp[0] = AMBIENT;
  915.     sscanf(buf, "%f,%f,%f", &tmp[1], &tmp[2], &tmp[3]);
  916.     fillbuf();
  917.     tmp[4] = DIFFUSE;
  918.     tmp[8] = ALPHA;
  919.     sscanf(buf, "%f,%f,%f,%f", &tmp[5], &tmp[6], &tmp[7], &tmp[9]);
  920.     fillbuf();
  921.     tmp[10] = SPECULAR;
  922.     sscanf(buf, "%f,%f,%f", &tmp[11], &tmp[12], &tmp[13]);
  923.     fillbuf();
  924.     tmp[14] = SHININESS;
  925.     sscanf(buf, "%f", &tmp[15]);
  926.     fillbuf();
  927.     tmp[16] = EMISSION;
  928.     sscanf(buf, "%f,%f,%f", &tmp[17], &tmp[18], &tmp[19]);
  929.     tmp[20] = LMNULL;
  930.  
  931.     for (i=0; i < mcount; i++)
  932.     if (bcmp(tmp, mlist[i].data, 20 * sizeof(float)) == 0)
  933.         return(i);
  934.  
  935.     if (mcount % 4 == 0)
  936.     mlist = (mat_t *)realloc(mlist, (mcount+4) * sizeof(mat_t));
  937.  
  938.     mlist[mcount].id = mcount + 0x1000;
  939.     bcopy(tmp, mlist[mcount].data, 21 * sizeof(float));
  940.     mcount++;
  941.  
  942.     return(i);
  943. }
  944.  
  945.  
  946. void resolve_mat(object_t *obj)
  947. {
  948.     int i;
  949.     geometry_t *g;
  950.  
  951.     for (i=0; i < obj->gcount; i++)
  952.     {
  953.     g = &obj->glist[i];
  954.     switch(g->type)
  955.     {
  956.         case SSECTION:
  957.         case LTV_GEOM:
  958.         case FSECTION:
  959.         case PSECTION:
  960.         case TLPU_GEOM:
  961.         g->material = mlist[obj->mlist[g->material]].id;
  962.         break;
  963.         default:
  964.         break;
  965.     }
  966.     }
  967. }
  968.  
  969.  
  970. void readerror(char *errbuf)
  971. {
  972.     fprintf(stderr, "Error reading \"%s\"\n", ifname);
  973.     fprintf(stderr, "Error: %s : line %d\n", errbuf, linenumber);
  974.     exit(-1);
  975. }
  976.  
  977.  
  978. int fillbuf()
  979. {
  980.     do
  981.     {
  982.     if (fgets(buf, 240, ifp) == NULL)
  983.         return(0);
  984.     linenumber++;
  985.     }
  986.     while (buf[0] == '\0' || buf[0] == '#');
  987.  
  988.     return(1);
  989. }
  990.  
  991.  
  992. int isbinary()
  993. {
  994.     if (getc(ifp) == '\0')
  995.     return(TRUE);
  996.     
  997.     rewind(ifp);
  998.     return(FALSE);
  999. }
  1000.  
  1001.  
  1002. object_t *breadobj(char *fname)
  1003. {
  1004.     object_t *obj;
  1005.     int ifd;
  1006.     node_t *b;
  1007.     geometry_t *g;
  1008.     polygon_t *p;
  1009.     int i, j, k;
  1010.  
  1011.     ifd = open(fname, O_RDONLY);
  1012.  
  1013.     /*
  1014.      *  skip over the first byte that says this is a binary file
  1015.      */
  1016.     lseek(ifd, 1, 1);
  1017.  
  1018.     obj = (object_t *)malloc(sizeof(object_t));
  1019.     read(ifd, obj, sizeof(object_t));
  1020.  
  1021.     obj->blist = (node_t *)malloc(sizeof(node_t) * obj->bcount);
  1022.     read(ifd, obj->blist, sizeof(node_t) * obj->bcount);
  1023.     for (i=0; i < obj->bcount; i++)
  1024.     {
  1025.     b = &obj->blist[i];
  1026.     if (b->tcount)
  1027.     {
  1028.         b->tlist = (int *)malloc(sizeof(int) * b->tcount);
  1029.         read(ifd, b->tlist, sizeof(int) * b->tcount);
  1030.     }
  1031.     if (b->scount)
  1032.     {
  1033.         b->slist = (int *)malloc(sizeof(int) * b->scount);
  1034.         read(ifd, b->slist, sizeof(int) * b->scount);
  1035.         b->stlist = (int *)malloc(sizeof(int) * b->scount);
  1036.         read(ifd, b->stlist, sizeof(int) * b->scount);
  1037.     }
  1038.     }
  1039.  
  1040.     if (obj->tcount)
  1041.     {
  1042.     obj->tlist = (trans_t *)malloc(sizeof(trans_t) * obj->tcount);
  1043.     read(ifd, obj->tlist, sizeof(trans_t) * obj->tcount);
  1044.     }
  1045.  
  1046.     obj->glist = (geometry_t *)malloc(sizeof(geometry_t) * obj->gcount);
  1047.     read(ifd, obj->glist, sizeof(geometry_t) * obj->gcount);
  1048.     for (i=0; i < obj->gcount; i++)
  1049.     {
  1050.     g = &obj->glist[i];
  1051.  
  1052.     g->vlist = (float **)malloc(sizeof(float *) * g->vcount);
  1053.     for (j=0; j < g->vcount; j++)
  1054.     {
  1055.         g->vlist[j] = (float *)malloc(sizeof(float) * 3);
  1056.         read(ifd, g->vlist[j], sizeof(float)*3);
  1057.     }
  1058.         
  1059.     if (g->nlist)
  1060.     {
  1061.         g->nlist = (float **)malloc(sizeof(float *) * g->vcount);
  1062.         for (j=0; j < g->vcount; j++)
  1063.         {
  1064.         g->nlist[j] = (float *)malloc(sizeof(float) * 3);
  1065.         read(ifd, g->nlist[j], sizeof(float)*3);
  1066.         }
  1067.     }
  1068.  
  1069.     if (g->clist)
  1070.     {
  1071.         g->clist = (long *)malloc(sizeof(long) * g->vcount);
  1072.         read(ifd, g->clist, sizeof(long) * g->vcount);
  1073.     }
  1074.  
  1075.     g->plist = (polygon_t *)malloc(sizeof(polygon_t) * g->pcount);
  1076.     read(ifd, g->plist, sizeof(polygon_t) * g->pcount);
  1077.     for (j=0; j < g->pcount; j++)
  1078.     {
  1079.         p = &g->plist[j];
  1080.  
  1081.         p->vlist = (float **)malloc(sizeof(float *) * p->vcount);
  1082.         p->vnlist = (int *)malloc(sizeof(int) * p->vcount);
  1083.         read(ifd, p->vnlist, sizeof(int) * p->vcount);
  1084.         for (k=0; k < p->vcount; k++)
  1085.         p->vlist[k] = g->vlist[p->vnlist[k]];
  1086.         if (g->nlist)
  1087.         {
  1088.         p->nlist = (float **)malloc(sizeof(float *) * p->vcount);
  1089.         for (k=0; k < p->vcount; k++)
  1090.             p->nlist[k] = g->nlist[p->vnlist[k]];
  1091.         }
  1092.         if (g->clist)
  1093.         {
  1094.         p->clist = (long *)malloc(sizeof(long) * p->vcount);
  1095.         for (k=0; k < p->vcount; k++)
  1096.             p->clist[k] = g->clist[p->vnlist[k]];
  1097.         }
  1098.     }
  1099.     }
  1100.  
  1101.     close(ifd);
  1102. }
  1103.